home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / info-service / www / src / midaswww-1.0 / midas.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-16  |  66.1 KB  |  2,509 lines
  1. #include <stdio.h>                              /* For printf and so on. */
  2. #include <setjmp.h>                             /* For setjmp and so on. */
  3. #include <stdlib.h>                             /* for system() etc.     */
  4. #include <Mrm/MrmAppl.h>                        /* Motif Toolkit and MRM */
  5. #include <X11/CoreP.h>  
  6. #include <X11/cursorfont.h>
  7. #include <Xm/List.h>
  8. #include <Xm/PushB.h>
  9. #include <Xm/DialogS.h>    
  10. #include <Xm/Command.h>    
  11. #include <Xm/BulletinB.h>
  12. #include "SGMLHyper.h"     
  13. #include "SGMLCompositeText.h"     
  14. #include "midaslist.h"     
  15. #include "midasoperand.h"
  16. #include "midaswidget.h"
  17. #include "midasshell.h"
  18. #include "Tree.h"
  19.  
  20. #if !defined(__STDC__) && !defined(_NO_PROTO)
  21. #define _NO_PROTO
  22. #endif
  23. #if defined(__STDC__) && defined(_NO_PROTO)
  24. #undef _NO_PROTO
  25. #endif
  26.  
  27. #ifdef __STDC__
  28. # ifndef MISSING_STDARG_H
  29. #  include <stdarg.h>
  30. # endif
  31. # define Va_start(a,b) va_start(a,b)
  32. #else
  33. # include <varargs.h>
  34. # define Va_start(a,b) va_start(a)
  35. #endif
  36.  
  37. #ifndef VAX
  38. #include <pwd.h>
  39. #endif
  40.  
  41. #ifdef EDITRES
  42.     extern void _XEditResCheckMessages();
  43. #endif
  44.  
  45. MidasOperand MidasGetIngot();
  46. MidasOperand MidasGetCreateCallback();
  47. void MidasLoadImage();
  48.  
  49. void MidasDispatchCommandCallback();
  50. MidasOperand MidasEvaluateExpression();
  51.  
  52. #ifndef VAX
  53. WidgetList DXmChildren();
  54. int DXmNumChildren();
  55. #endif
  56.  
  57. /*
  58.  * Global data            
  59.  */                                  
  60.  
  61. Display         *display;        /* Display variable */
  62. XtAppContext    app_context;        /* application context */
  63.  
  64. static Widget WidgetTree = NULL;        
  65. static Widget MidasMain;                /* Root widget ID of main */
  66.                                         /* MRM fetch */
  67.  
  68. #define HASHTABLESIZE 137
  69. static MidasWidget *HashTable[HASHTABLESIZE];
  70.  
  71. struct QueuedCommand {
  72.     Widget                Widget;
  73.     char                 *Command;
  74.     struct QueuedCommand *Next; 
  75. };
  76.  
  77. typedef struct QueuedCommand QueuedCommand;
  78.  
  79. static struct {
  80.     QueuedCommand *Head;
  81.     QueuedCommand *Tail;
  82. } CommandQueue;
  83.  
  84. struct MidasFile {
  85.     MrmHierarchy         Hierarchy;
  86.     Widget               DefaultParent;
  87. };
  88.  
  89. typedef struct MidasFile MidasFile;
  90.  
  91. struct ConvertPair {
  92.     char    *Name;
  93.     char    Value;
  94. };
  95.  
  96. typedef struct ConvertPair ConvertPair;
  97.  
  98. static int ExitResponse;
  99.  
  100. static ConvertPair ConvertBoolean[] = {{"true",1}, 
  101.                                        {"false",0},
  102.                                        {0,0}};
  103.  
  104. static XtConvertArgRec ConvertBooleanArg[] =
  105. {{XtAddress,(XtPointer) ConvertBoolean,sizeof(XtPointer)}};
  106.  
  107. static ConvertPair ConvertPacking[] = {{"XmPACK_TIGHT" ,1},
  108.                                        {"XmPACK_COLUMN",2},
  109.                                        {"XmPACK_NONE"  ,3},
  110.                                        {0,0}};
  111. static XtConvertArgRec ConvertPackingArg[] =
  112. {{XtAddress,(XtPointer) ConvertPacking,sizeof(XtPointer)}};
  113. static XtConvertArgRec ConvertWidgetArg[] = {{XtBaseOffset,0,sizeof(Widget)}};
  114.  
  115. static List   *MidasWidgetList;
  116. static List   *MidasFileList;
  117. static List   *MidasShellList;
  118.  
  119. static XtTranslations MidasTranslations;
  120.  
  121. Widget ActiveWidget;
  122. XmAnyCallbackStruct *ActiveCallback;
  123. Boolean IfState;
  124.  
  125. static char ProblemStrings[2000];
  126. static char *ProblemPtr = ProblemStrings;
  127.  
  128. /* we need some protection here against exceeding the buffer size */
  129.  
  130. jmp_buf JmpEnv[100];
  131. int NumJump = 0; 
  132.  
  133. static Widget MidasFindName();
  134. void *MidasConvertExpression();
  135.  
  136. static XtErrorMsgHandler OldHandler;
  137.  
  138. void MidasDummyHandler(){}
  139. void MidasSuppressXtWarningMessages()
  140. {
  141.   OldHandler = XtAppSetWarningMsgHandler(app_context,MidasDummyHandler);
  142. }
  143. void MidasReenableXtWarningMessages()
  144. {
  145.   XtAppSetWarningMsgHandler(app_context,OldHandler);
  146. }
  147. static char *MidasClassName(w)
  148. Widget w;
  149. {
  150.    CoreClassPart *Class = (CoreClassPart *) XtClass(w);
  151.    return Class->class_name; 
  152. }
  153. Widget MidasGetActiveWidget()
  154. {
  155.   return ActiveWidget;
  156. }
  157. XmString MidasCharToString(C)  /*---Convert a char * to an XmString */
  158.       char *C;
  159. {
  160.     return XmStringCreateSimple(C);
  161. }
  162. #ifndef _NO_PROTO
  163. void MidasError(char *fmt,...)
  164. #else
  165. /* VARARGS2*/
  166. void MidasError(fmt,va_alist)
  167. char *fmt;
  168. va_dcl
  169. #endif
  170. {
  171.     va_list args;
  172.     Va_start(args, fmt);
  173.      
  174.     vsprintf(ProblemPtr, fmt, args);
  175.     printf("Error: %s\n",ProblemPtr);
  176.     ProblemPtr += strlen(ProblemPtr);
  177.     *ProblemPtr++ = '\n';
  178.     va_end(args);
  179.  
  180.     if (NumJump > 0) longjmp(JmpEnv[--NumJump],1);
  181.  
  182.     *--ProblemPtr = '\0';
  183.       {
  184.         Widget w;
  185.         XmString string = XmStringCreateLtoR(ProblemStrings,
  186.                                              XmSTRING_DEFAULT_CHARSET);   
  187.         int n = 0; 
  188.         Arg args[10];
  189.         XtSetArg(args[n],XmNmessageString, string); n++;
  190.  
  191.         w = MidasFindName("MidasErrorBox");
  192.         if (w != 0)
  193.           {
  194.             XtSetValues(w,args,n);
  195.             XtFree(string);
  196.             XtManageChild(w);
  197.           }
  198.       }
  199.     ProblemPtr = ProblemStrings;
  200. };
  201. char *MidasStringToChar(string) /*----Convert an XmString to a char */
  202.      XmString string;
  203. {
  204.     XmStringContext   context;
  205.     char              *result;
  206.     XmStringCharSet   charset;
  207.     XmStringDirection direction;
  208.     Boolean           separator;
  209.  
  210.     XmStringInitContext(&context,string); 
  211.     XmStringGetNextSegment(context,&result,&charset,&direction,&separator); 
  212.     XmStringFreeContext(context);
  213.  
  214.     return result;
  215. };
  216. void MidasScanChildren(w,Rtn,Closure1,Closure2)
  217.       Widget w;
  218.       void (*Rtn)();
  219.       XtPointer Closure1;
  220.       XtPointer Closure2;
  221. {
  222.    int n;
  223.    Widget *list;  
  224.  
  225.    if (XtIsSubclass(w,compositeWidgetClass))
  226.       {
  227.         list = DXmChildren(w);
  228.         n = DXmNumChildren(w);
  229.       
  230.         for (; n > 0; n-- , list++) Rtn(*list,Closure1,Closure2); 
  231.       }
  232.  
  233.    if (SGMLIsCompositeText(w))
  234.       {
  235.         Arg arglist[10];
  236.         int nn = 0;
  237.   
  238.         XtSetArg(arglist[nn],XtNchildren,&list); nn++;
  239.         XtSetArg(arglist[nn],XtNnumChildren,&n); nn++;
  240.         XtGetValues(w,arglist,nn);
  241.         
  242.         for (; n > 0; n-- , list++) Rtn(*list,Closure1,Closure2); 
  243.       }
  244.  
  245.    if (XtIsWidget(w) && w->core.screen != 0)
  246.      {
  247.        list = w->core.popup_list;
  248.        n = w->core.num_popups;       
  249.  
  250.        if (list != NULL) for (; n > 0; n-- , list++) Rtn(*list,Closure1,Closure2); 
  251.      }
  252. }
  253. void MidasScanAncestors(w,Rtn,Closure1)
  254.       Widget w;
  255.       void (*Rtn)();
  256.       XtPointer Closure1;
  257. {
  258.    int n;
  259.    Widget *list;  
  260.  
  261.    Rtn(w,Closure1);
  262.    MidasScanChildren(w,MidasScanAncestors,(XtPointer) Rtn,Closure1);
  263. }
  264. static MrmHierarchy MidasOpenUidFile(name,parent)
  265. char *name;
  266. Widget parent;
  267. {
  268.     MrmHierarchy hierarchy; 
  269.     MidasFile *mfile;
  270.     ListItem *item;
  271.     
  272.     MrmOpenHierarchy(1, &name, NULL, &hierarchy);
  273.     item = MidasAddItemToList(MidasFileList,name);
  274.     mfile = XtNew(MidasFile);
  275.     mfile->DefaultParent = parent;
  276.     mfile->Hierarchy = hierarchy;
  277.     item->Pointer = mfile;
  278.  
  279.     return hierarchy;
  280. }
  281. void MidasWidgetBeingDestroyed(w,mw,reason)
  282.     Widget w;
  283.     MidasWidget *mw;
  284.     MidasWidget **reason;
  285. {
  286.     /* remove from hash chain */ 
  287.  
  288.     int hash = ((int) w) % HASHTABLESIZE;
  289.     MidasWidget *loop = HashTable[hash];
  290.   
  291.     if (loop == mw) HashTable[hash] = mw->HashChain;
  292.     else 
  293.       { 
  294.         for ( ; loop->HashChain != mw; loop = loop->HashChain);
  295.         loop->HashChain = mw->HashChain;  
  296.       }  
  297.  
  298.     if (mw->Map       != NULL) XtDestroyWidget(mw->Map);
  299.     if (mw->IngotList != NULL) MidasDestroyIngots(mw);
  300.     if (mw->NameEntry != NULL) MidasRemoveItemFromList(MidasWidgetList,mw->NameEntry);
  301.     else XtFree((char *) mw);
  302. }
  303. MidasWidget *MidasWidgetToMW(w)
  304. Widget w;
  305. /*
  306.  *  This routine returns a pointer to the MidasWidget structure for any widget.
  307.  */ 
  308. {
  309.     int hash = ((int) w) % HASHTABLESIZE;
  310.     MidasWidget *mw = HashTable[hash];
  311.   
  312.     for ( ; mw != NULL; mw = mw->HashChain)
  313.       if (mw->Widget == w) return mw;
  314.   
  315.     mw = XtNew(MidasWidget);
  316.     mw->Widget       = w;
  317.     mw->ShowChildren = False;
  318.     mw->Map          = NULL;
  319.     mw->IngotList    = NULL;
  320.     mw->Parent       = NULL;
  321.     mw->NameEntry    = NULL;
  322.     mw->HashChain    = HashTable[hash];
  323.     mw->Inited       = FALSE;
  324.     HashTable[hash]  = mw;
  325.  
  326.     return mw;
  327. }
  328. static void MidasRegisterName(name,w)
  329. char *name;
  330. Widget w;
  331. {
  332.     ListItem *item = MidasFindItemInList(MidasWidgetList,name);
  333.     if (item == NULL || ((MidasWidget *) item->Pointer)->Widget != w) 
  334.       {
  335.         MidasWidget *mw = MidasWidgetToMW(w);
  336.  
  337.         item = MidasAddItemToList(MidasWidgetList,name);
  338.         item->Pointer = mw;
  339.         mw->NameEntry = item;
  340.       }
  341. }
  342. static void MidasAddChildTree(Child,mw)
  343. Widget Child;
  344. MidasWidget *mw;
  345. {
  346.   Widget w;
  347.   MidasWidget *newmw = MidasWidgetToMW(Child);
  348.   XmString label; 
  349.   Arg arglist[3];
  350.   int n = 0;
  351.   
  352.   if (WidgetTree == NULL) return; 
  353.  
  354.   label = MidasCharToString(XtName(Child)); 
  355.    
  356.   if (mw != NULL) { XtSetArg(arglist[n],XtNtreeParent,mw->Map); n++; }
  357.   XtSetArg(arglist[n],XmNuserData,Child); n++;
  358.   XtSetArg(arglist[n],XmNlabelString,label); n++;
  359.  
  360.   w = XmCreatePushButton(WidgetTree,"TreeLeaf",arglist,n);
  361.  
  362.   XmStringFree(label);
  363.  
  364.   XtManageChild(w);
  365.   newmw->Map = w;
  366. }   
  367. static void MidasRemoveChildTree(Child)
  368. Widget Child;
  369. {
  370.   MidasWidget *mw = MidasWidgetToMW(Child);
  371.  
  372.   if (mw->ShowChildren) MidasScanChildren(Child,MidasRemoveChildTree,NULL,NULL);
  373.  
  374.   if (mw->Map != NULL) 
  375.     {
  376.       XtDestroyWidget(mw->Map);
  377.       mw->Map = NULL;
  378.     }
  379.   mw->ShowChildren = FALSE;   
  380. }
  381. static void MidasToggleChildrenTree(w)
  382. Widget w;
  383. {
  384.   MidasWidget *mw = MidasWidgetToMW(w);
  385.  
  386.   if (WidgetTree == NULL) return;
  387.  
  388.   mw->ShowChildren = !mw->ShowChildren;
  389.   if (mw->ShowChildren) MidasScanChildren(w,MidasAddChildTree,(XtPointer) mw,NULL);   
  390.   else                  MidasScanChildren(w,MidasRemoveChildTree,NULL,NULL);    
  391. }
  392. void MidasSetupWidget(w)
  393. Widget w;
  394. {
  395.     typedef struct _MR { char *Ingots; char *CreateCallback; } MidasResources;
  396.     MidasResources result;
  397.     MidasWidget *mw = MidasWidgetToMW(w);
  398.     MidasWidget *parent = MidasWidgetToMW(XtParent(w));
  399.     
  400. #define Offset(field) XtOffsetOf(MidasResources,field)
  401.  
  402.     static XtResource resources[] = 
  403.       {{"midasIngots"           ,"MidasIngots"         ,XtRString ,sizeof(char *),
  404.          Offset(Ingots)         ,XtRImmediate          ,NULL},
  405.        {"midasCreateCallback"   ,"MidasCreateCallback" ,XtRString ,sizeof(char *),
  406.          Offset(CreateCallback) ,XtRImmediate          ,NULL}};
  407.  
  408. #undef Offset
  409.     /*
  410.      *  Check if widget already initialized
  411.      */       
  412.  
  413.     if (mw->Inited) return; 
  414.     mw->Inited = TRUE;
  415.      
  416.     /*
  417.      * If the widgets parent has show children (in the widget tree)
  418.      * then make it so
  419.      */
  420.      
  421.     if (parent->ShowChildren) MidasAddChildTree(w,parent);
  422.          
  423.     /*  
  424.      *  Add the special midas translation to all Widget children
  425.      */
  426.  
  427.     if (XtIsWidget(w)) XtOverrideTranslations(w,MidasTranslations);
  428.  
  429.  
  430.     XtAddCallback(w,XtNdestroyCallback,MidasWidgetBeingDestroyed,(XtPointer) mw);
  431.  
  432.     XtGetApplicationResources(w,(XtPointer)&result,resources,XtNumber(resources),NULL,0);
  433.     if (result.Ingots != NULL) MidasSetupIngots(mw,result.Ingots);
  434.     if (result.CreateCallback != NULL) 
  435.       {
  436.         MidasSetIngotString(w,"midasCreateCallback",result.CreateCallback);
  437.         MidasDispatchCommandCallback(w,result.CreateCallback,NULL);
  438.       }
  439. }
  440. Widget MidasCreateWidget(Parent,Class,Name)
  441. Widget Parent;
  442. WidgetClass Class;
  443. char *Name;
  444. {
  445.     Widget w = XtCreateManagedWidget(Name,Class,Parent,NULL,0);
  446.     MidasRegisterName(Name,w);
  447.     MidasSetupWidget(w);
  448.     return w;
  449. }
  450. Widget MidasFetch(name,parent)
  451. char *name;
  452. Widget parent;
  453. {
  454.     MrmType class;
  455.     Widget actualParent, widget = 0;
  456.     MidasFile *mfile;
  457.     ListItem *i;
  458.     Boolean Dialog = MidasGetQualifier("DIALOG");
  459.     static LookingForParent = FALSE;
  460.  
  461.     if (!LookingForParent)
  462.       { 
  463.         LookingForParent = TRUE;
  464.         MidasGetQualifier("PARENT",&parent);
  465.         LookingForParent = FALSE;
  466.       }
  467.  
  468.     for (i=MidasFileList->First; i != 0; i=i->Next)
  469.       {
  470.         mfile = i->Pointer;
  471.         if (parent==0) actualParent = mfile->DefaultParent;
  472.         else           actualParent = parent;
  473.         if (Dialog) 
  474.           {
  475.             Arg args[10];
  476.             int n = 0;
  477.             char *dialogName = strcat(strcpy(XtMalloc(strlen(name)+7),name),"Dialog");
  478.             Widget Dw = XmCreateDialogShell(actualParent,dialogName,NULL,0);
  479.             XtSetArg(args[n],XmNx, 0); n++;
  480.             XtSetArg(args[n],XmNy, 0); n++;
  481.             if (MrmFetchWidgetOverride(mfile->Hierarchy,name,Dw,NULL,
  482.                                        args,n,&widget,&class)
  483.                 ==MrmSUCCESS) 
  484.               {
  485.                 MidasRegisterName(name,widget);
  486.                 MidasScanAncestors(Dw,MidasSetupWidget,NULL); 
  487.                 return widget;
  488.               }
  489.             XtDestroyWidget(Dw);
  490.           }
  491.         else 
  492.           {
  493.             if (MrmFetchWidget(mfile->Hierarchy,name,actualParent,&widget,&class) == MrmSUCCESS) 
  494.               {
  495.                 MidasRegisterName(name,widget);
  496.                 MidasScanAncestors(widget,MidasSetupWidget,NULL); 
  497.                 return widget;
  498.               }
  499.           }
  500.       }
  501.     return 0;
  502. }
  503. Pixmap MidasFetchIcon(name)
  504. char *name;
  505. {
  506.     Pixmap PixMap;
  507.     ListItem *i;
  508.     MidasSuppressXtWarningMessages(); 
  509.  
  510.     for (i=MidasFileList->First; i != 0; i=i->Next)
  511.       {
  512.         MidasFile *mfile = i->Pointer;
  513.         Widget w = mfile->DefaultParent;
  514.         Screen *screen = XtScreen(w);
  515.         Pixel foreground = WhitePixelOfScreen(screen);
  516.         Pixel background = BlackPixelOfScreen(screen);
  517.  
  518.         if (MrmFetchIconLiteral(mfile->Hierarchy,name,
  519.                                 screen, XtDisplay(w),
  520.                                 foreground, background, &PixMap)  
  521.             == MrmSUCCESS)
  522.         { 
  523.           MidasReenableXtWarningMessages();
  524.           /* printf("found icon at %x!!!\n",PixMap); */
  525.           return PixMap;
  526.         } 
  527.       }
  528.     MidasReenableXtWarningMessages();
  529.     /* printf("failed to find icon!!!\n"); */
  530.     return 0;
  531. }
  532. static Widget MidasFindName(name)
  533. char *name;
  534. {
  535.     ListItem *item = MidasFindItemInList(MidasWidgetList,name);
  536.     if (item != 0) 
  537.       {
  538.         MidasWidget *mw = item->Pointer;
  539.         return mw->Widget;
  540.       }
  541.     else 
  542.       {
  543.         return MidasFetch(name,0);
  544.       }
  545. }
  546. void MidasFetchDispatchEvent()
  547. {
  548.     XEvent event;
  549.     XtAppNextEvent(app_context,&event);
  550.     XtDispatchEvent(&event);
  551. }
  552. void MidasGetCallbacks(L,w)
  553. List *L;
  554. Widget w;
  555. {
  556.     unsigned int numResource;
  557.     XtResource *Resource, *R;
  558.  
  559.     WidgetClass Class = XtClass(w);
  560.  
  561.     MidasEmptyList(L);
  562.     MidasAddItemToList(L,"midasCreateCallback");
  563.  
  564.     XtGetResourceList(Class,&Resource,&numResource);
  565.     
  566.     for (R=Resource; numResource-- > 0; R += 1)
  567.       if (strcmp(R->resource_type,"Callback") == 0)
  568.         {
  569.            ListItem *item = MidasAddItemToList(L,R->resource_name);
  570.         }
  571. }
  572. void MidasGetResources(L,w)
  573. List *L;
  574. Widget w;
  575. {
  576.     unsigned int numResource;
  577.     XtResource *Resource, *R;
  578.  
  579.     WidgetClass Class = XtClass(w);
  580.  
  581.     MidasEmptyList(L);
  582.  
  583.     XtGetResourceList(Class,&Resource,&numResource);
  584.     
  585.     for (R=Resource; numResource-- > 0; R += 1)
  586.       if (strcmp(R->resource_type,"Callback") != 0)
  587.         {
  588.            ListItem *item = MidasAddItemToList(L,R->resource_name);
  589.         }
  590. }
  591. MidasOperand MidasGetAppResource(w,ResourceName)
  592. Widget w;
  593. char *ResourceName;
  594. {
  595.     static XtResource resources = 
  596.       {"userData","UserData",XtRString,sizeof(char *),0,XtRString,""};
  597.  
  598.     char *result="";
  599.     MidasOperand Temp;
  600.     XtResource *rt = XtNew(XtResource);
  601.  
  602.     *rt = resources;
  603.     rt->resource_name = XtNewString(ResourceName);
  604.     XtGetApplicationResources(w,(XtPointer) &result,rt,1,NULL,0);
  605.  
  606.     Temp.Value.P = result;
  607.     Temp.Dynamic = FALSE;
  608.     Temp.Type = MString;
  609.  
  610.     return Temp;
  611. }
  612. MidasOperand MidasGetValue(w,ResourceName)
  613. Widget w;
  614. char *ResourceName;
  615. {
  616.     MidasOperand Temp;
  617.     char result[200], *ret;
  618.     unsigned int numResource;
  619.     int notfound = 1;
  620.     XtResource *Resource, *R;
  621.     WidgetClass Class = XtClass(w);
  622.  
  623.  
  624.     /*  Special handling for midasCreateCallback resource
  625.      */
  626.  
  627.     if (strcmp(ResourceName,"midasCreateCallback") == 0) return MidasGetCreateCallback(w);
  628.       
  629.     XtGetResourceList(Class,&Resource,&numResource);
  630.     
  631.     for (R=Resource; numResource-- > 0; R += 1)
  632.       {
  633.         if (strcmp(R->resource_name,ResourceName) == 0)
  634.           {
  635.             notfound = 0;
  636.             if (strcmp(R->resource_type,XtRString) == 0)
  637.               {
  638.                 char *ptr;
  639.                 int n=0;
  640.                 Arg args[10];
  641.                 XtSetArg(args[n],ResourceName,&ptr); n++;
  642.                 XtGetValues(w,args,n);
  643.                 ret = XtNewString(ptr);
  644.               }
  645.             else if (strcmp(R->resource_type,"XmString") == 0)  
  646.               {
  647.                 String ptr;
  648.                 int n=0;
  649.                 Arg args[10];
  650.                 XtSetArg(args[n],ResourceName, &ptr); n++;
  651.                 XtGetValues(w,args,n);
  652.                 if (ptr == 0) ret = XtNewString("");
  653.                 else          ret = MidasStringToChar(ptr);
  654.               }
  655.             else
  656.               {
  657.                 XrmValue from,to;
  658.                 if (strcmp(R->resource_type,"Callback") == 0)  
  659.                   {
  660.                     int n = 0;
  661.                     Arg args[10];
  662.                     XtSetArg(args[n],ResourceName, &from.addr); n++;
  663.                     XtGetValues(w,args,n);
  664.                   }
  665.                 else from.addr = ((char *) w) + R->resource_offset;  
  666.  
  667.                 from.size = R->resource_size; 
  668.                 to.size = 200;
  669.                 to.addr = result;
  670.                 XtConvertAndStore(w,R->resource_type,&from,XtRString,&to);
  671.                 if (to.size > 200)
  672.                   {
  673.                     ret = XtMalloc(to.size);
  674.                     to.addr = ret;
  675.                     XtConvertAndStore(w,R->resource_type,&from,XtRString,&to);
  676.  
  677.                   }
  678.                 else ret = XtNewString(result);
  679.              }
  680.           }
  681.        }
  682.     XtFree((char *)Resource);
  683.     if (notfound) MidasError("Resource %s not found",ResourceName);
  684.     Temp.Value.P = ret;
  685.     Temp.Dynamic = TRUE;
  686.     Temp.Type = MString;
  687.     return Temp;
  688. }
  689. MidasShell *MidasGetShell(w)
  690. Widget w;
  691. {
  692.     MidasShell *ms;
  693.     ListItem *i;
  694.  
  695.     for (; ; w = XtParent(w))
  696.       for (i = MidasShellList->First; i != 0; i = i->Next)
  697.         {
  698.           ms = i->Pointer;
  699.           if (ms->Widget == w) return ms; 
  700.         }
  701. }      
  702. void MidasDispatchAndTrapErrors(command)
  703. char *command;
  704. {
  705.     if (setjmp(JmpEnv[NumJump++]) == 0)
  706.       {
  707.         MidasDispatchCommand(command);
  708.         NumJump--;
  709.       }
  710.     else MidasError("Error interpreting command: %s\n       from widget %s (class %s)"
  711.                     ,command,XtName(ActiveWidget),MidasClassName(ActiveWidget));
  712. }
  713. static void midas_command_proc(w,tag,reason)
  714.     Widget w;
  715.     char *tag;
  716.     XmCommandCallbackStruct *reason;
  717. {
  718.     char *command = MidasStringToChar(reason->value);
  719.     Widget Stack = ActiveWidget;
  720.     Boolean StackIf = IfState;
  721.  
  722.     ActiveWidget = w;
  723.     IfState = FALSE;
  724.     
  725.     MidasDispatchAndTrapErrors(command);
  726.  
  727.     ActiveWidget = Stack;
  728.     IfState = StackIf;
  729.     XtFree(command);
  730. };
  731. void MidasEchoCommand(command)
  732. char *command;
  733. {
  734.     XmString s = MidasCharToString(command);
  735.     Widget w = MidasFindName("MidasCommand");
  736.     if (w != 0) w = XmCommandGetChild(w,XmDIALOG_HISTORY_LIST);
  737.     if (w != 0) 
  738.       {  
  739.         XmListAddItem(w,s,0);
  740.         XmListSetBottomPos(w,0);
  741.       }
  742.     XmStringFree(s);
  743. #ifdef debug
  744.     printf("Executing Command: %s\n",command);
  745. #endif
  746. }
  747. void MidasDispatchCommandCallback(w,tag,reason)
  748.     Widget w;
  749.     char *tag;
  750.     XmAnyCallbackStruct *reason;
  751. {
  752.     char buffer[2000];
  753.     char *p = tag , *q = buffer;
  754.     Widget Stack = ActiveWidget;
  755.     XmAnyCallbackStruct *CStack = reason;
  756.  
  757.     ActiveWidget = w;
  758.     ActiveCallback = reason;    
  759.  
  760.     for (;; p++)
  761.       {
  762.         if (*p == '\n' || *p == ';') 
  763.           {
  764.             *q = '\0';
  765.             if (*buffer != '\0')
  766.               {
  767.                 MidasEchoCommand(buffer);
  768.                 MidasDispatchAndTrapErrors(buffer);
  769.               }
  770.             q = buffer;
  771.           }
  772.         else if (*p == '\0') 
  773.           {
  774.             *q = '\0';
  775.             if (*buffer != '\0')
  776.               {
  777.                 MidasEchoCommand(buffer);
  778.                 MidasDispatchAndTrapErrors(buffer);
  779.               }
  780.             break;
  781.           }
  782.         else if (*p == '%') MidasForceEvaluateExpression(&p,&q);
  783.         else *q++ = *p;
  784.       }
  785.     ActiveWidget = Stack;
  786.     ActiveCallback = CStack;
  787. };
  788. void MidasSendActionProc(w,event,params,num_params)
  789.     Widget w;
  790.     XEvent *event;
  791.     String *params;
  792.     Cardinal *num_params;
  793. {
  794.     MidasDispatchCommandCallback(w,*params,NULL);    
  795. }
  796. void MidasSpecialActionProc(w,event,params,num_params)
  797.     Widget w;
  798.     XButtonEvent *event;
  799.     String *params;
  800.     Cardinal *num_params;
  801. {
  802. /*
  803.  * Check to see if the event really came from some child gadget
  804.  * or insenstive widget
  805.  */    
  806.     Widget OldWidget = 0;
  807.  
  808.     for ( ;w != OldWidget && XtIsComposite(w); )
  809.       {
  810.         Widget *list = DXmChildren(w);
  811.         int n = DXmNumChildren(w);
  812.        
  813.         OldWidget = w;
  814.  
  815.         for (; n>0; n--, list++)
  816.           {
  817.             if (!XtIsWidget(*list) || !XtIsSensitive(*list))
  818.               {
  819.                 Dimension width, height;
  820.                 Position x,y;
  821.                 Arg arglist[4];
  822.                 XtSetArg(arglist[0],XmNx,&x);
  823.                 XtSetArg(arglist[1],XmNy,&y);
  824.                 XtSetArg(arglist[2],XmNwidth ,&width);
  825.                 XtSetArg(arglist[3],XmNheight,&height);
  826.                 XtGetValues(*list,arglist,4);
  827.                 if (event->x >= x && event->x < x+width &&
  828.                     event->y >= y && event->y < y+height) 
  829.                   {
  830.                     w = *list;
  831.                     break;      
  832.                   }
  833.               }
  834.           }
  835.       }
  836.     MidasDispatchCommandCallback(w,*params,NULL);    
  837. }
  838. void MidasQueueCommand(w,Command)
  839. Widget w;
  840. char *Command;
  841. {
  842.     QueuedCommand *QC = XtNew(QueuedCommand);
  843.     QC->Widget = w;
  844.     QC->Command = XtNewString(Command); 
  845.     QC->Next = 0;
  846.     if (CommandQueue.Head == 0) CommandQueue.Head = QC;
  847.     else                        CommandQueue.Tail->Next = QC;
  848.     CommandQueue.Tail = QC;
  849. }
  850. void MidasDispatchQueuedCommands()
  851. {
  852.     QueuedCommand *QC, *Next;
  853.     for (QC = CommandQueue.Head; QC != 0; QC = Next)
  854.       {
  855.         MidasDispatchCommandCallback(QC->Widget, QC->Command, 0);
  856.         XtFree(QC->Command);
  857.         Next = QC->Next;
  858.         XtFree((char *)QC);
  859.       }
  860.    CommandQueue.Head = 0;
  861.    CommandQueue.Tail = 0;
  862. }
  863. void MidasIgnore(Command)
  864. char *Command;
  865. {
  866.     MidasDispatchCommandCallback(ActiveWidget,Command,NULL);
  867. }
  868. void MidasIf(Doit,Command)
  869. Boolean Doit;
  870. char *Command;
  871. {
  872.     if (Doit) MidasDispatchCommandCallback(ActiveWidget,Command,NULL);
  873.     IfState = Doit;
  874. }
  875. void MidasElseIf(Doit,Command)
  876. Boolean Doit;
  877. char *Command;
  878. {
  879.     if (!IfState) MidasIf(Doit,Command);
  880. }
  881. void MidasElse(Command)
  882. char *Command;
  883. {
  884.     if (!IfState) MidasDispatchCommandCallback(ActiveWidget,Command,NULL);
  885. }
  886. void MidasBeep(pcent,w)
  887. int pcent;
  888. Widget w;
  889. {
  890.     if (w == NULL) w = ActiveWidget;
  891.     XBell(XtDisplay(w),pcent);
  892. }
  893.  
  894. /*
  895.  * This procedure will ensure that, if a dialog window is being mapped,
  896.  * its contents become visible before returning.  It is intended to be
  897.  * used just before a bout of computing that doesn't service the display.
  898.  * You should still call XmUpdateDisplay() at intervals during this
  899.  * computing if possible.
  900.  *
  901.  * The monitoring of window states is necessary because attempts to map
  902.  * the dialog are redirected to the window manager (if there is one) and
  903.  * this introduces a significant delay before the window is actually mapped
  904.  * and exposed.  This code works under mwm, twm, uwm, and no-wm.  It
  905.  * doesn't work (but doesn't hang) with olwm if the mainwindow is iconified.
  906.  *
  907.  * The argument to ForceDialog is any widget in the dialog (often it
  908.  * will be the BulletinBoard child of a DialogShell).
  909.  */
  910.  
  911. void MidasForceDialog(w)
  912. Widget w;
  913. {
  914.   Widget diashell, topshell;
  915.   Window diawindow, topwindow;
  916.   Display *dpy;
  917.   XWindowAttributes xwa;
  918.   XEvent event;
  919.   XtAppContext cxt;
  920.  
  921. /* Locate the shell we are interested in.  In a particular instance, you
  922.  * may know these shells already.
  923.  */
  924.  
  925.   for (diashell = w;
  926.        !XtIsShell(diashell);
  927.        diashell = XtParent(diashell))
  928.     ;
  929.  
  930. /* Locate its primary window's shell (which may be the same) */
  931.  
  932.   for (topshell = diashell;
  933.        !XtIsTopLevelShell(topshell);
  934.        topshell = XtParent(topshell))
  935.     ;
  936.  
  937.   if (XtIsRealized(diashell) && XtIsRealized(topshell)) {
  938.     dpy = XtDisplay(topshell);
  939.     diawindow = XtWindow(diashell);
  940.     topwindow = XtWindow(topshell);
  941.     cxt = XtWidgetToApplicationContext(diashell);
  942.  
  943. /* Wait for the dialog to be mapped.  It's guaranteed to become so unless... */
  944.  
  945.     while (XGetWindowAttributes(dpy, diawindow, &xwa),
  946.            xwa.map_state != IsViewable) {
  947.  
  948. /* ...if the primary is (or becomes) unviewable or unmapped, it's
  949.    probably iconified, and nothing will happen. */
  950.  
  951.       if (XGetWindowAttributes(dpy, topwindow, &xwa),
  952.           xwa.map_state != IsViewable)
  953.         break;
  954.  
  955. /* At this stage, we are guaranteed there will be an event of some kind.
  956.    Beware; we are presumably in a callback, so this can recurse. */
  957.  
  958.       XtAppNextEvent(cxt, &event);
  959.       XtDispatchEvent(&event);
  960.     }
  961.   }
  962.  
  963. /* The next XSync() will get an expose event if the dialog was unmapped. */
  964.  
  965.   XmUpdateDisplay(topshell);
  966. }
  967. void MidasSetCursor(w,c)
  968. Widget w;
  969. int c;
  970. {
  971.     Cursor C;
  972.  
  973.     if (c!=0) C = XCreateFontCursor(XtDisplay(w),c);
  974.     else      C = None;
  975.  
  976.     XDefineCursor(XtDisplay(w),XtWindow(w),C);
  977.     XFlush(XtDisplay(w));
  978. }
  979. void MidasSetSensitive(w,Sensitive)
  980. Widget w;
  981. Boolean Sensitive;
  982. {
  983.     XtSetSensitive(w,Sensitive);
  984. }
  985. char *MidasGetWidgetName(w)
  986. Widget w;
  987. {
  988.     char *parent, *thisone, *new;
  989.     int pl, tl;
  990.     MidasShell *ms = MidasGetShell(w);
  991.  
  992.     thisone = XtName(w);
  993.     if (*thisone == '\0' || strchr(thisone,'-') != 0)
  994.       MidasError("Can not STORE RESOURCE for unnamed widget");
  995.  
  996.     parent = XtName(ms->Widget);
  997.     pl = strlen(parent);
  998.     tl = strlen(thisone);
  999.     new = XtMalloc(pl+tl+2);
  1000.  
  1001.     strcpy(new,parent);
  1002.     if (ms->Widget != w)
  1003.       {
  1004.         strcat(new,"*");
  1005.         strcat(new,thisone);
  1006.       }
  1007.  
  1008.     return new;
  1009. }
  1010. void MidasSetValue(w,ResourceName,Op)
  1011. Widget w;
  1012. char *ResourceName;
  1013. MidasOperand *Op;
  1014. {
  1015.     char *result;
  1016.     unsigned int numResource;
  1017.     int found = FALSE;
  1018.     XtResource *Resource, *R;
  1019.     WidgetClass Class = XtClass(w);
  1020.  
  1021.     if (strcmp(ResourceName,"midasCreateCallback") == 0) 
  1022.       {
  1023.         MidasSetIngotP(w,ResourceName,Op);
  1024.         return;
  1025.       }
  1026.  
  1027.     XtGetResourceList(Class,&Resource,&numResource);
  1028.  
  1029.     for (R=Resource; numResource-- > 0; R += 1)
  1030.       {    
  1031.         if (strcmp(R->resource_name,ResourceName) == 0)
  1032.           {
  1033.             Arg arglist[1];
  1034.  
  1035.             found = TRUE;
  1036.                  
  1037.             MidasConvertOperand(Op,R->resource_type);
  1038.             XtSetArg(arglist[0],ResourceName,Op->Value.P);
  1039.             XtSetValues(w,arglist,1);              
  1040.  
  1041.             break;
  1042.           }
  1043.       }
  1044.  
  1045.     XtFree((char *) Resource);
  1046.     if (!found) MidasError("Resource %s not found",ResourceName);
  1047. }
  1048. static void MidasStoreAppResource(w,resource,value)
  1049. Widget w;
  1050. char *resource;
  1051. char *value;
  1052. {
  1053.     char *name = MidasGetWidgetName(w);
  1054.     char *new = XtMalloc(strlen(name)+strlen(resource)+2);
  1055.     MidasShell *ms = MidasGetShell(w);
  1056.  
  1057.     strcpy(new,name);
  1058.     strcat(new,".");
  1059.     strcat(new,resource);
  1060.  
  1061.     XrmPutStringResource(&ms->Database,new,value);
  1062.     ms->Changes++;
  1063.  
  1064.     XtFree(new);
  1065.     XtFree(name);
  1066. }
  1067. static void MidasStoreResource(w,resource)
  1068. Widget w;
  1069. char *resource;
  1070. {
  1071.     MidasOperand Temp;
  1072.     Temp = MidasGetValue(w,resource);
  1073.  
  1074.     if (strcmp(Temp.Type,MString)) MidasConvertOperand(Temp,MString);
  1075.    
  1076.     MidasStoreAppResource(w,resource,Temp.Value.P);
  1077.     if (Temp.Dynamic) XtFree(Temp.Value.P);
  1078. }
  1079. static void MidasSaveStoredResources(w)
  1080. Widget w;
  1081. {
  1082.     MidasShell *ms = MidasGetShell(w);
  1083.     XrmPutFileDatabase(ms->Database, ms->Filename);
  1084.     ms->Changes = 0; 
  1085. }
  1086. static void MidasSaveGeometry(w)
  1087. Widget w;
  1088. {
  1089.     MidasStoreResource(w,XmNx);
  1090.     MidasStoreResource(w,XmNy);
  1091.     MidasStoreResource(w,XmNwidth);
  1092.     MidasStoreResource(w,XmNheight);
  1093.     MidasSaveStoredResources(w);        
  1094. }
  1095. static void MidasHelpOnContext(w)
  1096. Widget w;
  1097. {
  1098.     MidasShell *ms = MidasGetShell(w);
  1099.     Cursor C =  XCreateFontCursor(XtDisplay(w),XC_question_arrow);
  1100.     Widget new = XmTrackingLocate(ms->Widget,C,FALSE);
  1101.  
  1102.     for (; new != NULL; new = XtParent(new))
  1103.       if (XtHasCallbacks(new,XmNhelpCallback) == XtCallbackHasSome)
  1104.         {
  1105.           XtCallCallbacks(new,XmNhelpCallback,NULL);
  1106.           break;
  1107.         }
  1108.     XFreeCursor(XtDisplay(w),C);
  1109. } 
  1110. static MidasOperand MidasInt(f)
  1111. float f;
  1112. {
  1113.     MidasOperand Temp;
  1114.     Temp.Dynamic = FALSE;
  1115.     Temp.Type = MInt;
  1116.     Temp.Value.I = (int) f;
  1117.     return Temp;
  1118. }
  1119. static void MidasSetFlag(w,flag)
  1120. Widget w;
  1121. int *flag;
  1122. {
  1123.   *flag = 1;
  1124. }
  1125. static MidasOperand MidasHasChildren(w)
  1126. Widget w;
  1127. {
  1128.     MidasOperand Temp;
  1129.     Temp.Dynamic = FALSE;
  1130.     Temp.Type = MBoolean;
  1131.     Temp.Value.I = FALSE;
  1132.   
  1133.     MidasScanChildren(w,MidasSetFlag,(XtPointer) &Temp.Value.I,NULL); 
  1134.     return Temp;
  1135. }
  1136. static MidasOperand MidasChildrenInTree(w)
  1137. Widget w;
  1138. {
  1139.     MidasOperand Temp;
  1140.     MidasWidget *mw = MidasWidgetToMW(w);
  1141.     Temp.Dynamic = FALSE;
  1142.     Temp.Type = MBoolean;
  1143.     Temp.Value.I = mw->ShowChildren;
  1144.     
  1145.     return Temp; 
  1146. }
  1147. static MidasOperand MidasStrnspn(s,t)
  1148. char *s;
  1149. char *t;
  1150. /*
  1151.     Exceedingly temporary
  1152. */
  1153. {
  1154.     MidasOperand Temp;
  1155.     char *p = s;
  1156.     for (;*p != '\0' && *p == ' '; p++);
  1157.     for (;*p != '\0' && *p != ' '; p++);
  1158.     *p = '\0';
  1159.  
  1160.     Temp.Dynamic = TRUE;
  1161.     Temp.Type = MString;
  1162.     Temp.Value.P = (XtPointer) XtNewString(s);
  1163.  
  1164.     return Temp;
  1165. }
  1166. static MidasOperand MidasGetWidgetId(w)
  1167. Widget w;
  1168. {
  1169.     MidasOperand Temp;
  1170.     Temp.Dynamic = FALSE;
  1171.     Temp.Type = MInt;
  1172.     Temp.Value.I = (int) w;
  1173.     return Temp;
  1174. }
  1175. static MidasOperand MidasIsManaged(w)
  1176. Widget w;
  1177. {
  1178.     MidasOperand Temp;
  1179.     int result = XtIsManaged(w);
  1180.     Temp.Dynamic = FALSE;
  1181.     Temp.Type = MBoolean;
  1182.     Temp.Value.I = (result != 0); 
  1183.     return Temp;
  1184. }
  1185. static MidasOperand MidasIsRealized(w)
  1186. Widget w;
  1187. {
  1188.     MidasOperand Temp;
  1189.     int result = XtIsRealized(w);
  1190.     Temp.Dynamic = FALSE;
  1191.     Temp.Type = MBoolean;
  1192.     Temp.Value.I = (result != 0); 
  1193.     return Temp;
  1194. }
  1195. static MidasOperand MidasGetOperandType(Op)
  1196. MidasOperand *Op;
  1197. {
  1198.     MidasOperand Temp;
  1199.  
  1200.     Temp.Dynamic = FALSE;
  1201.     Temp.Type = MString;
  1202.     Temp.Value.P = Op->Type;
  1203.     return Temp;
  1204. }
  1205. static MidasOperand MidasWidgetFunction(w)
  1206. Widget w;
  1207. {
  1208.     MidasOperand Temp;
  1209.     Temp.Dynamic = FALSE;
  1210.     Temp.Type = MWidget;
  1211.     Temp.Value.P = (XtPointer) w;
  1212.     return Temp;
  1213. }
  1214. static MidasOperand MidasFetchFunction(name,parent)
  1215. char *name;
  1216. Widget parent;
  1217. {
  1218.     MidasOperand Temp;
  1219.     Temp.Dynamic = FALSE;
  1220.     Temp.Type = MWidget;
  1221.     Temp.Value.P = (XtPointer) MidasFetch(name,parent);
  1222.     return Temp;
  1223. }
  1224. static MidasOperand MidasParent(w)
  1225. Widget w;
  1226. {
  1227.     MidasOperand Temp;
  1228.     Temp.Dynamic = FALSE;
  1229.     Temp.Type = MWidget;
  1230.     Temp.Value.P = (XtPointer) XtParent(w);
  1231.     return Temp;
  1232. }
  1233. static MidasOperand MidasShellFunction(w)
  1234. Widget w;
  1235. {
  1236.     MidasOperand Temp;
  1237.     MidasShell *ms = MidasGetShell(w);
  1238.  
  1239.     Temp.Dynamic = FALSE;
  1240.     Temp.Type = MWidget;
  1241.     Temp.Value.P = (XtPointer) ms->Widget;
  1242.     return Temp;
  1243. }
  1244. static MidasOperand MidasWidgetName(w)
  1245. Widget w;
  1246. {
  1247.     MidasOperand Temp;
  1248.     char *name = XtName(w); 
  1249.   
  1250.     if (*name == '\0') 
  1251.       {
  1252.         name = XtMalloc(24);
  1253.         sprintf(name,"No Name (%d)",w);
  1254.         Temp.Dynamic = TRUE;
  1255.       }
  1256.     else Temp.Dynamic = FALSE;
  1257.  
  1258.     Temp.Value.P = name;
  1259.     Temp.Type = MString;
  1260.     return Temp;
  1261. }
  1262. static MidasOperand MidasWidgetClass(w)
  1263. Widget w;
  1264. {
  1265.     MidasOperand Temp;
  1266.     Temp.Dynamic = FALSE;
  1267.     Temp.Type = MString;
  1268.     Temp.Value.P = MidasClassName(w);
  1269.     return Temp;
  1270. }
  1271. static MidasOperand MidasGetCommand()
  1272. {
  1273.     MidasOperand Temp;
  1274.     XmCommandCallbackStruct *cb = (XmCommandCallbackStruct *) ActiveCallback;
  1275.  
  1276.     if (ActiveCallback->reason != XmCR_COMMAND_ENTERED) 
  1277.       MidasError("GETCOMMAND requires callback reason XmCR_COMMAND_ENTERED");
  1278.  
  1279.     Temp.Dynamic = TRUE;
  1280.     Temp.Type = MString;
  1281.     Temp.Value.P = MidasStringToChar(cb->value);
  1282.     return Temp;
  1283. }
  1284. static MidasOperand MidasGetClickCount()
  1285. {
  1286.     MidasOperand Temp;
  1287.     XmPushButtonCallbackStruct *cb = (XmPushButtonCallbackStruct *) ActiveCallback;
  1288.     if (ActiveCallback->reason != XmCR_ACTIVATE) 
  1289.       MidasError("GETCLICKCOUNT requires callback reason XmCR_ACTIVATE");
  1290.   
  1291.     Temp.Dynamic = FALSE;
  1292.     Temp.Type = MInt;
  1293.     Temp.Value.I = cb->click_count;
  1294.     return Temp;
  1295. }
  1296. static MidasOperand MidasHyperGetText()
  1297. {
  1298.     MidasOperand Temp;
  1299.     SGMLHyperCallbackStruct *cb = (SGMLHyperCallbackStruct *) ActiveCallback;
  1300. /*
  1301.     if (ActiveCallback->reason != SGMLHYPER_REASON)
  1302.       MidasError("HYPERGETTEXT requires callback reason SGMLHYPER_REASON");
  1303. */
  1304.     Temp.Dynamic = TRUE;
  1305.     Temp.Type = MString;
  1306.     Temp.Value.P = XtNewString(cb->text);
  1307.     return Temp;
  1308. }
  1309. static MidasOperand MidasHyperGetHidden()
  1310. {
  1311.     MidasOperand Temp;
  1312.     SGMLHyperCallbackStruct *cb = (SGMLHyperCallbackStruct *) ActiveCallback;
  1313. /*
  1314.     if (ActiveCallback->reason != SGMLHYPER_REASON)
  1315.       MidasError("HYPERGETTEXT requires callback reason SGMLHYPER_REASON");
  1316. */
  1317.     Temp.Dynamic = TRUE;
  1318.     Temp.Type = MString;
  1319.     Temp.Value.P = XtNewString(cb->hidden);
  1320.     return Temp;
  1321. }
  1322. static MidasOperand MidasHyperGrep(w,string)
  1323. Widget w;
  1324. char *string;
  1325. {
  1326.     MidasOperand Temp;
  1327.     Boolean result = SGMLHyperGrep(w,string,TRUE,FALSE,TRUE);
  1328.  
  1329.     Temp.Value.I = result;
  1330.     Temp.Type = MBoolean;
  1331.     Temp.Dynamic = FALSE;
  1332.     return Temp;
  1333. }
  1334. #ifndef VAX
  1335. static String MidasGetRootDirName(buf)
  1336. String buf;
  1337. {
  1338. #ifndef X_NOT_POSIX
  1339.      uid_t uid;
  1340. #else
  1341.      int uid;
  1342.      extern int getuid();
  1343. #ifndef SYSV386
  1344.      extern struct passwd *getpwuid(), *getpwnam();
  1345. #endif
  1346. #endif
  1347.      struct passwd *pw;
  1348.      static char *ptr = NULL;
  1349.  
  1350.      if (ptr == NULL) {
  1351.     if (!(ptr = getenv("HOME"))) {
  1352.         if (ptr = getenv("USER")) pw = getpwnam(ptr);
  1353.         else {
  1354.         uid = getuid();
  1355.          pw = getpwuid(uid);
  1356.         }
  1357.         if (pw) ptr = pw->pw_dir;
  1358.         else {
  1359.         ptr = NULL;
  1360.         *buf = '\0';
  1361.         }
  1362.     }
  1363.      }
  1364.  
  1365.      if (ptr)
  1366.      (void) strcpy(buf, ptr);
  1367.  
  1368.      buf += strlen(buf);
  1369.      *buf = '/';
  1370.      buf++;
  1371.      *buf = '\0';
  1372.      return buf;
  1373. }
  1374. #endif
  1375. static char* MidasGetAppUserDefaults(dpy,name)
  1376. Display *dpy;
  1377. char *name;
  1378. {
  1379.     char *filename;
  1380. #ifdef VAX
  1381.  
  1382.     static char file[] = "DECW$USER_DEFAULTS:", ext[] = ".DAT"; 
  1383.     int totlen;
  1384.  
  1385.     totlen = strlen(file) + strlen(ext) + strlen(name) + 1;
  1386.     filename = XtMalloc(totlen);
  1387.     strcpy(filename,file);
  1388.     strcat(filename,name);
  1389.     strcat(filename,ext);
  1390.  
  1391. #else
  1392.  
  1393.     char* path;
  1394.     Boolean Alloc=False;
  1395.     char homedir[256];
  1396.     MidasGetRootDirName(homedir);
  1397.  
  1398.     if (!(path = getenv("XUSERFILESEARCHPATH"))) {
  1399.     char *old_path;
  1400.     if (!(old_path = getenv("XAPPLRESDIR"))) {
  1401.         char *path_default = "%s/%%L/%%N%%C:%s/%%l/%%N%%C:%s/%%N%%C:%s/%%L/%%N:%s/%%l/%%N:%s/%%N";
  1402.         path = XtMalloc(6*strlen(homedir) + strlen(path_default));
  1403.         sprintf( path, path_default,
  1404.             homedir, homedir, homedir, homedir, homedir, homedir );
  1405.     } else {
  1406.         char *path_default = "%s/%%L/%%N%%C:%s/%%l/%%N%%C:%s/%%N%%C:%s/%%N%%C:%s/%%L/%%N:%s/%%l/%%N:%s/%%N:%s/%%N";
  1407.         path = XtMalloc( 6*strlen(old_path) + 2*strlen(homedir) + strlen(path_default));
  1408.         sprintf(path, path_default, old_path, old_path, old_path, homedir,
  1409.             old_path, old_path, old_path, homedir );
  1410.     }
  1411.         Alloc=True;
  1412.     }
  1413.     filename = XtResolvePathname(dpy,NULL,name,NULL,path,NULL,0,NULL);
  1414.     if (!filename) 
  1415.       {
  1416.          filename = XtMalloc(strlen(homedir)+strlen(name)+1);
  1417.          strcpy(filename,homedir);
  1418.          strcat(filename,name); 
  1419.       }
  1420.     if (Alloc) XtFree(path);
  1421.  
  1422. #endif
  1423.    return filename;
  1424. }
  1425. Widget MidasCreateDialog(name)
  1426. char *name;
  1427. {
  1428.     Widget parent, dialog;
  1429.     if (MidasGetQualifier("PARENT",&parent) == 0) MidasError("Parent required");
  1430.     dialog = XmCreateDialogShell(parent,name,NULL,0);
  1431.     MidasRegisterName(name,dialog);
  1432.     return dialog;
  1433. }
  1434. Widget MidasCreateShellArg(name,argv,argc)
  1435. char *name;
  1436. String *argv;
  1437. Cardinal *argc;
  1438. {
  1439.     int totlen; 
  1440.     char *new;
  1441.     ListItem *item;
  1442.     MidasShell *ms = XtNew(MidasShell);
  1443.     char *ShellName = XtNewString(name);
  1444.     char *ShellClass = XtNewString(name);
  1445.     char *uidfile;
  1446.     Pixmap icon;
  1447.     Widget w;
  1448.  
  1449.     *ShellName = tolower(*ShellName);
  1450.     *ShellClass = toupper(*ShellClass);
  1451.  
  1452.     display = XtOpenDisplay(app_context,NULL,NULL,ShellClass,
  1453.                         NULL, 0, argc, argv);
  1454.     if (display == 0) { MidasError("Could not open display"); exit(0); }
  1455.  
  1456.     w = XtAppCreateShell(ShellName,ShellClass,
  1457.                          applicationShellWidgetClass,
  1458.                          display, NULL, 0);
  1459.    
  1460.     new = MidasGetAppUserDefaults(display,ShellClass);
  1461.  
  1462.     XtFree(ShellName);
  1463.     XtFree(ShellClass);
  1464.  
  1465.     item = MidasAddItemToList(MidasShellList,name);
  1466.     item->Pointer = ms;
  1467.  
  1468.     ms->Widget = w;
  1469.     ms->Database = XrmGetFileDatabase(new);
  1470.     ms->Filename = new;
  1471.     ms->Changes = 0; 
  1472.  
  1473.     MidasSetupWidget(w);
  1474.     MidasRegisterName(name,w);
  1475.  
  1476.     if (MidasGetQualifier("UIDFILE",&uidfile)) MidasOpenUidFile(uidfile,w);
  1477.     if (MidasGetQualifier("ICON",&icon)) 
  1478.       { 
  1479.         int n = 0;
  1480.         Arg args[10];
  1481.         XtSetArg(args[n],XmNiconPixmap, icon); n++;
  1482.         XtSetValues(w, args, n);
  1483.       }
  1484. #ifdef EDITRES
  1485.     XtAddEventHandler(w, (EventMask)0, True,
  1486.                   _XEditResCheckMessages, (XtPointer)NULL);
  1487. #endif
  1488.  
  1489.     /* Shells are always displayed in the Widget Tree */
  1490.     
  1491.     MidasAddChildTree(w,NULL);
  1492.  
  1493.     return w;
  1494. }
  1495. Widget MidasCreateShell(name)
  1496. char *name;
  1497. {
  1498.   Cardinal zilch=0;
  1499.   return MidasCreateShellArg(name,NULL,&zilch);
  1500. }
  1501. static MidasOperand MidasTreeToWidget(w)
  1502. Widget w;
  1503. {
  1504.   MidasOperand Temp;
  1505.   Arg arglist[1];
  1506.   XtSetArg(arglist[0],XmNuserData,&Temp.Value.P);
  1507.   XtGetValues(w,arglist,1);
  1508.   
  1509.   Temp.Type = MWidget;
  1510.   Temp.Dynamic = FALSE;
  1511.    
  1512.   return Temp;
  1513. }
  1514. void MidasCreateWidgetTree(Tree)
  1515. Widget Tree;
  1516. {
  1517.   ListItem *item;
  1518.  
  1519.   WidgetTree = Tree;
  1520.  
  1521.   for (item = MidasShellList->First; item != 0; item = item->Next)
  1522.     {
  1523.       MidasShell *ms = (MidasShell *) item->Pointer;
  1524.       MidasAddChildTree(ms->Widget,NULL);   
  1525.     }   
  1526. }
  1527. static void MidasInvertWidget(w)
  1528. Widget w;
  1529. { 
  1530.   Arg arglist[2];
  1531.   Pixel fg; 
  1532.   Pixel bg;  
  1533.  
  1534.   XtSetArg(arglist[0],XmNforeground,&fg);
  1535.   XtSetArg(arglist[1],XmNbackground,&bg);
  1536.   XtGetValues(w,arglist,2);
  1537.  
  1538.   XtSetArg(arglist[0],XmNforeground,bg);
  1539.   XtSetArg(arglist[1],XmNbackground,fg);
  1540.   XtSetValues(w,arglist,2);
  1541. }
  1542. static void MidasCurrentWidgetInTree(w)
  1543. Widget w;
  1544. {
  1545.   static Widget OldWidget = NULL;
  1546.   Widget TreeW; 
  1547.   MidasWidget *mw, *parent;
  1548.   
  1549.   if (OldWidget != NULL)
  1550.     {
  1551.       mw = MidasWidgetToMW(OldWidget);
  1552.       TreeW = mw->Map;
  1553.       if (TreeW != NULL) MidasInvertWidget(TreeW);
  1554.     }
  1555.   OldWidget = w;
  1556.   
  1557.   mw = MidasWidgetToMW(w); 
  1558.  
  1559.   /* if this widget isnt in the tree, make it so */ 
  1560.  
  1561.   for (; mw->Map  == NULL; )
  1562.     {
  1563.       for (parent = mw; parent->Map == NULL ; parent = MidasWidgetToMW(XtParent(parent->Widget)) );
  1564.       MidasToggleChildrenTree(parent->Widget); 
  1565.     }
  1566.  
  1567.   TreeW = mw->Map;
  1568.   MidasInvertWidget(TreeW); 
  1569.  
  1570.   /* it may be necessary to scroll the tree to make this widget visible */
  1571.  
  1572.   {
  1573.      Arg arglist[10];
  1574.      int n=0;
  1575.      Widget h_scroll, v_scroll;
  1576.   
  1577.      Widget Tree = XtParent(TreeW);
  1578.      Widget Clip = XtParent(Tree);
  1579.      Widget Swin = XtParent(Clip);
  1580.  
  1581.      Position    x_button,y_button;
  1582.      Dimension   h_button,w_button;
  1583.      Position    x_clip,y_clip;
  1584.      Dimension   h_clip,w_clip;
  1585.      Position    dv=0,dh=0;
  1586.      int min,max;
  1587.      int v_val,v_size,v_inc,v_page;
  1588.      int h_val,h_size,h_inc,h_page;
  1589.      Position x,y;
  1590.  
  1591.     /* Get window scroll bars */
  1592.  
  1593.      XtSetArg(arglist[n],XmNhorizontalScrollBar, &h_scroll); n++;
  1594.      XtSetArg(arglist[n],XmNverticalScrollBar,   &v_scroll); n++;
  1595.      XtGetValues(Swin,arglist,n);
  1596.       
  1597.     /* Get size of clip window and button */
  1598.  
  1599.      n = 0;
  1600.      XtSetArg(arglist[n],XmNwidth,  &w_clip); n++;
  1601.      XtSetArg(arglist[n],XmNheight, &h_clip); n++;
  1602.      XtGetValues(Clip,arglist,n);
  1603.  
  1604.      n = 0;
  1605.      XtSetArg(arglist[n],XmNwidth,  &w_button); n++;
  1606.      XtSetArg(arglist[n],XmNheight, &h_button); n++;
  1607.      XtGetValues(TreeW,arglist,n);
  1608.  
  1609.     /* Get global coordinates of clip and selection rect */
  1610.  
  1611.      XtTranslateCoords(Clip,0,0,&x_clip,&y_clip);
  1612.      XtTranslateCoords(TreeW,0,0,&x_button,&y_button);
  1613.  
  1614.     /* offset of selection within clip window */
  1615.  
  1616.      x = x_button - x_clip;
  1617.      y = y_button - y_clip;
  1618.  
  1619.     /* selection y coordinate is not visible */
  1620.  
  1621.      if( y < 0 || y + h_button > h_clip)
  1622.      {
  1623.         /* the widget must be moved verticaly by dv pixels */
  1624.  
  1625.         dv = (y + h_button / 2)  - h_clip / 2;
  1626.  
  1627.         n = 0;
  1628.         XtSetArg(arglist[n],XmNminimum,&min); n++;
  1629.         XtSetArg(arglist[n],XmNmaximum,&max); n++;
  1630.  
  1631.         XtGetValues(v_scroll,arglist,n);
  1632.  
  1633.         XmScrollBarGetValues(v_scroll,&v_val,&v_size,&v_inc,&v_page);
  1634.  
  1635.         max -= v_size;
  1636.  
  1637.         if( dv + v_val > max ) dv = max - v_val;
  1638.         if( dv + v_val < min ) dv = min - v_val;
  1639.      }
  1640.  
  1641.     /* selection x coordinate is not visible */
  1642.  
  1643.      if( x < 0 || x + w_button > w_clip)
  1644.      {
  1645.         /* the widget must be moved horizontaly by dh pixels */
  1646.  
  1647.         dh = (x + w_button / 2)  - w_clip / 2;
  1648.  
  1649.         n = 0;
  1650.         XtSetArg(arglist[n],XmNminimum,&min); n++;
  1651.         XtSetArg(arglist[n],XmNmaximum,&max); n++;
  1652.         XtGetValues(h_scroll,arglist,n);
  1653.  
  1654.         XmScrollBarGetValues(h_scroll,&h_val,&h_size,&h_inc,&h_page);
  1655.  
  1656.         max -= h_size;
  1657.  
  1658.         if( dh + h_val > max ) dh = max - h_val;
  1659.         if( dh + h_val < min ) dh = min - h_val;
  1660.  
  1661.      }
  1662.  
  1663.     /* if the widget must be moved */
  1664.  
  1665.      if(dv || dh)
  1666.      {
  1667.         Position x,y;
  1668.   
  1669.         n = 0;
  1670.         XtSetArg(arglist[n],XmNx,&x); n++;
  1671.         XtSetArg(arglist[n],XmNy,&y); n++;
  1672.         XtGetValues(Tree,arglist,n);
  1673.  
  1674.         x -= dh;
  1675.         y -= dv;
  1676.  
  1677.         /* move it */
  1678.  
  1679.         n = 0;
  1680.         XtSetArg(arglist[n],XmNx,x); n++;
  1681.         XtSetArg(arglist[n],XmNy,y); n++;
  1682.         XtSetValues(Tree,arglist,n);
  1683.  
  1684.         /* update scroll bars */
  1685.  
  1686.         if(dv) XmScrollBarSetValues(v_scroll,v_val+dv,v_size,v_inc,
  1687.             v_page,TRUE);
  1688.         if(dh) XmScrollBarSetValues(h_scroll,h_val+dh,h_size,h_inc,
  1689.             h_page,TRUE);
  1690.  
  1691.       }
  1692.     }
  1693.  
  1694. }
  1695. Widget MidasTraceWidgetTree(root,path)
  1696. Widget root;
  1697. char *path;
  1698. {
  1699.     Widget w = root;
  1700.  
  1701.     if (strcmp(path,"") ==  0) return w;
  1702.     else if (strncmp("^^^",path,3) == 0) 
  1703.       {
  1704.         path += 3;
  1705.         for (w = XtParent(w); w != 0; w = XtParent(w)) 
  1706.           {
  1707.             Widget result = MidasTraceWidgetTree(w,path);
  1708.             if (result != 0) return result;
  1709.           }
  1710.         return 0;
  1711.       }
  1712.     else if (*path == '^') 
  1713.       {
  1714.         path += 1;
  1715.         w = XtParent(w);
  1716.         return MidasTraceWidgetTree(w,path);
  1717.       }
  1718.     else if (strncmp("...",path,3) == 0) 
  1719.       {
  1720.         Widget *list, *save;  
  1721.         int n , nsave;
  1722.       
  1723.         if (XtIsSubclass(w,compositeWidgetClass) != 0)
  1724.           { 
  1725.  
  1726.             save = DXmChildren(w);  
  1727.             nsave = DXmNumChildren(w);
  1728.  
  1729.             path += 3; 
  1730.             for (list = save , n = nsave; n > 0; n-- , list++) 
  1731.               { 
  1732.                 Widget result = MidasTraceWidgetTree(*list,path);
  1733.                 if (result != 0) return result;
  1734.               }
  1735.             path -= 3;
  1736.             for (list = save , n = nsave; n > 0; n-- , list++) 
  1737.               { 
  1738.                 Widget result = MidasTraceWidgetTree(*list,path);
  1739.                 if (result != 0) return result;
  1740.               }
  1741.           }
  1742.         if (XtIsWidget(w))
  1743.           {
  1744.             save = w->core.popup_list;
  1745.             nsave = w->core.num_popups;       
  1746.        
  1747.             for (list = save , n = nsave; n > 0; n-- , list++) 
  1748.               { 
  1749.                 Widget result = MidasTraceWidgetTree(*list,path);
  1750.                 if (result != 0) return result;
  1751.               }
  1752.             return 0;
  1753.           }
  1754.       }
  1755.     else if (*path == '.') 
  1756.       {
  1757.         Widget *list;  
  1758.         int n;  
  1759.       
  1760.         if (XtIsSubclass(w,compositeWidgetClass) == 0) return 0;
  1761.  
  1762.         list = DXmChildren(w); 
  1763.         n = DXmNumChildren(w);   
  1764.  
  1765.         path += 1;
  1766.         for (; n > 0; n-- , list++) 
  1767.           { 
  1768.             Widget result = MidasTraceWidgetTree(*list,path);
  1769.             if (result != 0) return result;
  1770.           }
  1771.         return 0;
  1772.       }
  1773.     else
  1774.       {
  1775.         char temp, *p, *e = 0;
  1776.  
  1777.         for (p=path; *p != '.' && *p != '^' && *p != '\0'; p++) 
  1778.           {
  1779.             if (*p == '=') e = p;
  1780.           }
  1781.  
  1782.         temp = *p;
  1783.         *p = '\0';               
  1784.  
  1785.  
  1786.         if (e == 0)
  1787.           {
  1788.             if (strcmp(path,"*") == 0) 
  1789.               {
  1790.                 *p = temp;
  1791.                 return MidasTraceWidgetTree(w,p);
  1792.               }
  1793.             else
  1794.               {
  1795.                 if (strcmp(XtName(w),path) == 0)
  1796.                   {
  1797.                     *p = temp;
  1798.                     return MidasTraceWidgetTree(w,p);
  1799.                   }
  1800.                 else if (strcmp(MidasClassName(w),path) == 0)
  1801.                   {
  1802.                     *p = temp;
  1803.                     return MidasTraceWidgetTree(w,p);
  1804.                   }
  1805.                 else
  1806.                   {
  1807.                     *p = temp;
  1808.                     return 0;
  1809.                   }
  1810.               }
  1811.           }
  1812.         else
  1813.           {
  1814.             unsigned int numResource;
  1815.             XtResource *Resource, *R;
  1816.             WidgetClass Class = XtClass(w);
  1817.  
  1818.             XtGetResourceList(Class,&Resource,&numResource);
  1819.     
  1820.             *e = '\0';
  1821.  
  1822.             for (R=Resource; numResource-- > 0; R += 1)
  1823.               if (strcmp(R->resource_name,path) == 0)
  1824.                 {
  1825.                   XtPointer ptr , result;
  1826.                   XrmValue from,to;
  1827.                   int n = 0;
  1828.                   Arg args[10];
  1829.                   XtSetArg(args[n],path,&result); n++;
  1830.  
  1831.                   XtGetValues(w, args, n);
  1832.                   *e = '=';
  1833.                   *p = temp;
  1834.  
  1835.                   from.size = strlen(e+1)+1; 
  1836.                   from.addr = e+1;
  1837.                   to.size = sizeof(XtArgVal);
  1838.                   to.addr = (XtPointer) &ptr;
  1839.                   XtConvertAndStore(w,XtRString,&from,R->resource_type,&to);
  1840.                   if (to.size > sizeof(XtArgVal)) 
  1841.                   {
  1842.                     Widget res;
  1843.                     XtPointer ptr = XtMalloc(to.size);
  1844.                     to.addr = ptr;
  1845.                     XtConvertAndStore(w,XtRString,&from,R->resource_type,&to);
  1846.  
  1847.                     if (memcmp(to.addr,result,to.size) == 0) 
  1848.                       res = MidasTraceWidgetTree(w,p);
  1849.                     else res = NULL;
  1850.  
  1851.                     XtFree((char *) ptr);
  1852.                     return res;
  1853.                   }
  1854.                 else
  1855.                   {
  1856.                     if (memcmp(to.addr,result,to.size) == 0) 
  1857.                       return MidasTraceWidgetTree(w,p);
  1858.                     else return 0;
  1859.                   }
  1860.                 } 
  1861.  
  1862.             *e = '=';
  1863.             *p = temp;
  1864.  
  1865.             return 0;
  1866.           }
  1867.       }
  1868. }
  1869. Widget MidasFindWidget(name)
  1870. char *name;
  1871. {
  1872.     Widget w, root;
  1873.     char temp, *p, *path = XtNewString(name);
  1874.  
  1875.     for (p = path+1; *p != '.' && *p != '^' && *p != '\0'; p++);
  1876.  
  1877.     temp = *p;
  1878.     *p = '\0';
  1879.  
  1880.     if (strcmp(path,".") == 0) root = ActiveWidget;
  1881.     else                       root = MidasFindName(path);
  1882.  
  1883.     if (root == 0) MidasError("Could not find widget %s",path);
  1884.  
  1885.     *p = temp;
  1886.     w = MidasTraceWidgetTree(root,p);
  1887.  
  1888.     if (w == 0) MidasError("Could not follow path %s",path);
  1889.  
  1890.     XtFree(path);
  1891.     return w;
  1892. }
  1893. static void MidasDestroy(widget)
  1894. Widget widget;
  1895. {
  1896.     XtDestroyWidget(widget);
  1897. }
  1898. int MidasExit()
  1899. {
  1900.     MidasShell *ms;
  1901.     ListItem *i;
  1902.     int mods = 0;
  1903.     Widget w;
  1904.  
  1905.     for (i = MidasShellList->First; i != 0; i = i->Next)
  1906.       {
  1907.         ms = i->Pointer;
  1908.         mods += ms->Changes; 
  1909.       }
  1910.  
  1911.     if (mods>0)
  1912.       {
  1913.         w = MidasFetch("MidasExitDialog",0);
  1914.         XtManageChild(w);
  1915.         ExitResponse = -1;
  1916.         for (;ExitResponse == -1;) MidasFetchDispatchEvent();
  1917.       }
  1918.     if (ExitResponse == 2 )              /* Cancel */   
  1919.       {
  1920.         XtUnmanageChild(w);
  1921.         return 0;    
  1922.       }
  1923.     if (ExitResponse == 1 )              /* Yes    */
  1924.       for (i = MidasShellList->First; i != 0; i = i->Next)
  1925.         {
  1926.           ms = i->Pointer;
  1927.           if (ms->Changes != 0)
  1928.             {
  1929.               XrmPutFileDatabase(ms->Database, ms->Filename);
  1930.               ms->Changes = 0; 
  1931.             }
  1932.         }
  1933.     return 1;
  1934. }
  1935. static void MidasExitCallback(w,tag,cbDataP)
  1936.       Widget w; 
  1937.       int    *tag; 
  1938.       XmAnyCallbackStruct *cbDataP;
  1939. {
  1940.     ExitResponse = *tag;
  1941. }
  1942. static void MidasQuit()
  1943. {
  1944.     if (CustomExit() && MidasExit()) exit(1);
  1945. }
  1946. void MidasClearWindow(w)
  1947. Widget w;
  1948. {
  1949.     XClearArea(XtDisplay(w),XtWindow(w),0,0,0,0,TRUE);
  1950. }
  1951. void MidasPopup(widget)
  1952. Widget widget;
  1953. {
  1954.     if (XtIsManaged(widget)==0) XtManageChild(widget);
  1955.     else if (XtIsRealized(widget)) 
  1956.       {
  1957.          Widget parent = XtParent(widget);
  1958.          if (XtIsShell(parent)) XRaiseWindow(XtDisplay(parent),XtWindow(parent));
  1959.       }
  1960.  
  1961.     if (XtIsRealized(widget)==0)
  1962.       {
  1963.         MidasShell *ms = MidasGetShell(widget);
  1964.         XtRealizeWidget(ms->Widget);
  1965.       }
  1966. }
  1967. static void MidasPopdown(widget)
  1968. Widget widget;
  1969. {
  1970.     MidasShell *ms = MidasGetShell(widget);
  1971.  
  1972.     if (ms->Widget == widget) widget = MidasTraceWidgetTree(widget,".");
  1973.     if (XtIsManaged(widget)) XtUnmanageChild(widget);
  1974.     if (XtParent(widget) == ms->Widget) XtUnrealizeWidget(ms->Widget); 
  1975.  
  1976. }
  1977. static void MidasToggle(widget)
  1978. Widget widget;
  1979. {
  1980.     if (XtIsManaged(widget)) MidasPopdown(widget);
  1981.     else                     MidasPopup(widget);
  1982. }
  1983. static void MidasCenterHorizontal(w,position)
  1984. Widget w;
  1985. int position;
  1986. {
  1987.     Dimension width;
  1988.     Position  offset;
  1989.     Widget parent = XtParent(w);
  1990.     int n = 0;
  1991.     Arg args[10];
  1992.  
  1993.     XtSetArg(args[n],XmNwidth, &width); n++;
  1994.  
  1995.     if (XmIsForm(parent) == 0)
  1996.       MidasError("Can only center widgets whose parent is FORM");
  1997.  
  1998.     XtGetValues(w,args,n);
  1999.  
  2000.     offset = -((int) width)/2;
  2001.       {
  2002.         int n = 0;
  2003.         Arg args[10];
  2004.         XtSetArg(args[n],XmNleftAttachment, XmATTACH_POSITION); n++;
  2005.         XtSetArg(args[n],XmNleftOffset,     offset);   n++, 
  2006.         XtSetArg(args[n],XmNleftPosition,   position); n++;
  2007.  
  2008.         XtSetValues(w,args,n);
  2009.       }
  2010. }
  2011. static void MidasInvokeApplication(AppName)
  2012. char *AppName;
  2013. {
  2014.     Widget toplevel_widget = MidasCreateShell(AppName);
  2015.     MidasOperand Temp;
  2016.     
  2017.     Temp = MidasGetAppResource(toplevel_widget,"startup");
  2018.     /* printf("\nThe startup string is %s\n",Temp.Value.P); */
  2019.  
  2020.     if (*Temp.Value.P != '\0') MidasQueueCommand(toplevel_widget,Temp.Value.P);
  2021. }                         
  2022. static MidasOperand MidasQueryUser(w)
  2023. Widget w;
  2024. {
  2025.     int flag = 0;
  2026.     Arg arglist[10];  
  2027.  
  2028.     if (!XmIsBulletinBoard(w))
  2029.       MidasError("QUERYUSER requires a widget of subclass BulletinBoard");
  2030.  
  2031.     XtAddCallback(w,XmNunmapCallback,MidasSetFlag,(XtPointer) &flag);
  2032.     XtSetArg(arglist[0],XmNdialogStyle,XmDIALOG_FULL_APPLICATION_MODAL);
  2033.     XtSetValues(w,arglist,1);
  2034.  
  2035.     MidasPopup(w);
  2036.  
  2037.     for (;flag == 0;) 
  2038.       {
  2039.         MidasDispatchQueuedCommands();
  2040.         MidasFetchDispatchEvent(); 
  2041.       }
  2042.  
  2043.     return MidasGetIngot(w,"result");
  2044. }
  2045.  
  2046. /* The names and addresses of Things that Mrm.has to bind.  The names do
  2047.  * not have to be in alphabetical order.  */
  2048.  
  2049. static MrmRegisterArg reglist[] = { 
  2050.     {"midas_command_proc", (caddr_t) midas_command_proc},
  2051.     {"midas_exit", (caddr_t) MidasExitCallback},
  2052.     {"SendMidas", (caddr_t) MidasDispatchCommandCallback}};
  2053.  
  2054. static XtActionsRec actions[] = {
  2055.     {"SendMidas"   , (XtActionProc) MidasSendActionProc},
  2056.     {"MidasSpecial", (XtActionProc) MidasSpecialActionProc}};
  2057.  
  2058. static Boolean MidasConvertStringToCallback(display,args,nargs,from,to,converter_data)
  2059.     Display    *display;
  2060.     XrmValue   *args;
  2061.     Cardinal   *nargs;
  2062.     XrmValue   *from;
  2063.     XrmValue   *to;
  2064.     XtPointer  *converter_data;
  2065. {
  2066.     int size = sizeof(XtPointer);
  2067.     XtPointer new;
  2068.     XtCallbackRec *Callback;
  2069.  
  2070.     if (*from->addr == '\0') Callback = 0;
  2071.     else 
  2072.       { 
  2073.  
  2074.     /* This stuff is currently never freed....need to implement destructor??? */
  2075.  
  2076.         Callback = (XtCallbackRec *) XtMalloc(sizeof(XtCallbackRec)*2);
  2077.         Callback[0].callback = (XtCallbackProc) MidasDispatchCommandCallback;
  2078.         Callback[0].closure  = (XtPointer) XtNewString((char *) from->addr);
  2079.         Callback[1].callback = NULL;
  2080.         Callback[1].closure  = NULL;
  2081.       }
  2082.  
  2083.     new = (XtPointer) &Callback;
  2084.  
  2085.     if (to->addr == 0)
  2086.       {
  2087.          to->addr = new;
  2088.          to->size = size;
  2089.          return TRUE;
  2090.       }
  2091.     else if  (to->size >= size)
  2092.       {
  2093.          memcpy(to->addr,new,size);
  2094.          to->size = size;
  2095.          return TRUE;
  2096.       }
  2097.     else
  2098.       {
  2099.          to->size = size;
  2100.          return FALSE;
  2101.       }
  2102. }
  2103. static Boolean MidasConvertCallbackToString(display,args,nargs,from,to,converter_data)
  2104.     Display    *display;
  2105.     XrmValue   *args;
  2106.     Cardinal   *nargs;
  2107.     XrmValue   *from;
  2108.     XrmValue   *to;
  2109.     XtPointer  *converter_data;
  2110. {
  2111.     XtCallbackRec *Callback = (XtCallbackRec *) from->addr;
  2112.     int size;
  2113.     XtPointer new;
  2114.     static char empty[] = "";
  2115.  
  2116.     if (Callback == 0)
  2117.       {
  2118.         new = empty;
  2119.       }
  2120.     else if (Callback[0].callback == (XtCallbackProc) MidasDispatchCommandCallback)
  2121.       {
  2122.         new = Callback[0].closure;
  2123.       }
  2124.     else 
  2125.       {
  2126.         new = empty;
  2127.       }
  2128.     size = strlen((char *) new) + 1;
  2129.  
  2130.     if (to->addr == 0)
  2131.       {
  2132.          to->addr = new;
  2133.          to->size = size;
  2134.          return TRUE;
  2135.       }
  2136.     else if  (to->size >= size)
  2137.       {
  2138.          memcpy(to->addr,new,size);
  2139.          to->size = size;
  2140.          return TRUE;
  2141.       }
  2142.     else
  2143.       {
  2144.          to->size = size;
  2145.          return FALSE;
  2146.       }
  2147. }
  2148. static Boolean MidasConvertStringTable(display,args,nargs,from,to,converter_data)
  2149.     Display    *display;
  2150.     XrmValue   *args;
  2151.     Cardinal   *nargs;
  2152.     XrmValue   *from;
  2153.     XrmValue   *to;
  2154.     XtPointer  *converter_data;
  2155. {
  2156.     XmString **string = (XmString **) from->addr;
  2157.     char *new;
  2158.     int size;
  2159.  
  2160.     if (*string == 0 || **string == 0)
  2161.       {
  2162.         new = XtNewString("");
  2163.         size = 1;
  2164.       }
  2165.     else
  2166.       {
  2167.         new = MidasStringToChar(**string);
  2168.         size = strlen(new) + 1;
  2169.       } 
  2170.     if (to->addr == 0)
  2171.       {
  2172.          to->addr = new;
  2173.          to->size = size;
  2174.          return TRUE;
  2175.       }
  2176.     else if  (to->size >= size)
  2177.       {
  2178.          strcpy(to->addr,new);
  2179.          to->size = size;
  2180.          XtFree(new);
  2181.          return TRUE;
  2182.       }
  2183.     else
  2184.       {
  2185.          to->size = size;
  2186.          XtFree(new);
  2187.          return FALSE;
  2188.       }
  2189. }
  2190. static Boolean MidasConvertEnum(display,args,nargs,from,to,converter_data)
  2191.     Display    *display;
  2192.     XrmValue   *args;
  2193.     Cardinal   *nargs;
  2194.     XrmValue   *from;
  2195.     XrmValue   *to;
  2196.     XtPointer  *converter_data;
  2197. {
  2198.     char *val = from->addr;
  2199.     char *new;
  2200.     int size;
  2201.     ConvertPair *cp = (ConvertPair *) args->addr;
  2202.  
  2203.     for (; cp->Name != 0; cp++)
  2204.       if (cp->Value == *val) { new = cp->Name; break; }
  2205.  
  2206.     if (cp->Name == 0) return FALSE;
  2207.     size =strlen(new);
  2208.  
  2209.     if (to->addr == 0)
  2210.       {
  2211.          to->addr = new;
  2212.          to->size = size;
  2213.          return TRUE;
  2214.       }
  2215.     else if  (to->size >= size)
  2216.       {
  2217.          strcpy(to->addr,new);
  2218.          to->size = size;
  2219.          return TRUE;
  2220.       }
  2221.     else
  2222.       {
  2223.          to->size = size;
  2224.          return FALSE;
  2225.       }
  2226. }
  2227. static Boolean MidasConvertInteger(display,args,nargs,from,to,converter_data)
  2228.     Display    *display;
  2229.     XrmValue   *args;
  2230.     Cardinal   *nargs;
  2231.     XrmValue   *from;
  2232.     XrmValue   *to;
  2233.     XtPointer  *converter_data;
  2234. {
  2235.     static char buffer[12];
  2236.     int size;
  2237.  
  2238.     if (from->size == sizeof(short int))
  2239.       {
  2240.         int i;
  2241.         short int s; 
  2242.         memcpy(&s,from->addr,sizeof(s));
  2243.         i = s;
  2244.         sprintf(buffer,"%d",i);
  2245.         size = 1 + strlen(buffer);
  2246.       }
  2247.     else
  2248.       {
  2249.         int s;
  2250.         memcpy(&s,from->addr,sizeof(s)); 
  2251.         sprintf(buffer,"%d",s);
  2252.         size = 1 + strlen(buffer);
  2253.       }
  2254.  
  2255.  
  2256.     if (to->addr == 0)
  2257.       {
  2258.          to->addr = buffer;
  2259.          to->size = size;
  2260.          return TRUE;
  2261.       }
  2262.     else if  (to->size >= size)
  2263.       {
  2264.          strcpy(to->addr,buffer);
  2265.          to->size = size;
  2266.          return TRUE;
  2267.       }
  2268.     else
  2269.       {
  2270.          to->size = size;
  2271.          return FALSE;
  2272.       }
  2273. }
  2274. void MidasMainLoop()
  2275. {
  2276.     for (;;)
  2277.       {
  2278.         MidasDispatchQueuedCommands();
  2279.         MidasFetchDispatchEvent();
  2280.       }
  2281. }
  2282. void MidasInvokeAction(w,name)
  2283. Widget w;
  2284. char *name;
  2285. {
  2286.     XtCallActionProc(w,name,NULL,NULL,0);
  2287. }
  2288. void MidasSystem(name)
  2289. char *name;
  2290. {
  2291.     system(name);
  2292. }
  2293. void MidasInvokeCallback(w,name)
  2294. Widget w;
  2295. char *name;
  2296. {
  2297.     XtCallCallbacks(w,name,NULL);
  2298. }
  2299. void MidasFlush(w)
  2300. Widget w;
  2301. {
  2302.     XFlush(XtDisplay(w));
  2303. }
  2304. void MidasUpdate(w)
  2305. Widget w;
  2306. {
  2307.     XmUpdateDisplay(w);
  2308. }
  2309. void MidasInitialize(argc,argv)
  2310. Cardinal argc;
  2311. char *argv[];
  2312. {
  2313.     MrmHierarchy MidasHierarchy;
  2314.     MrmType *dummy_class;
  2315.     Pixmap PixMap;
  2316.     Pixel foreground,background;
  2317.     Widget MidasMenu;
  2318.     char junk[100];
  2319.     MidasOperand Temp;
  2320.     Widget toplevel_widget;
  2321.     int i;
  2322.     
  2323.     for (i=0; i < HASHTABLESIZE; i++) HashTable[i] = NULL;
  2324.  
  2325.     MidasWidgetList = MidasCreateEmptyList("MidasWidgets");
  2326.     MidasFileList   = MidasCreateEmptyList("MidasFiles");
  2327.     MidasShellList  = MidasCreateEmptyList("MidasShells");
  2328.  
  2329.     CommandQueue.Head = 0;
  2330.     CommandQueue.Tail = 0;
  2331.  
  2332.     MrmInitialize();                 /* Initialize MRM before initializing */
  2333.                                      /* the X Toolkit. */
  2334.  
  2335.     /* If we had user-defined widgets, we would register them with Mrm.here. */
  2336.  
  2337.     /* Set up initial command parsing stuff */
  2338.  
  2339.     XtSetTypeConverter("XmStringTable","String",MidasConvertStringTable,
  2340.                        NULL,0,XtCacheNone,NULL);
  2341.     XtSetTypeConverter("ShellVertPos","String",MidasConvertInteger,
  2342.                        NULL,0,XtCacheNone,NULL);
  2343.     XtSetTypeConverter("ShellHorizPos","String",MidasConvertInteger,
  2344.                        NULL,0,XtCacheNone,NULL);
  2345.     XtSetTypeConverter("ShellVertDim","String",MidasConvertInteger,
  2346.                        NULL,0,XtCacheNone,NULL);
  2347.     XtSetTypeConverter("ShellHorizDim","String",MidasConvertInteger,
  2348.                        NULL,0,XtCacheNone,NULL);
  2349.     XtSetTypeConverter("VerticalPosition","String",MidasConvertInteger,
  2350.                        NULL,0,XtCacheNone,NULL);
  2351.     XtSetTypeConverter("HorizontalPosition","String",MidasConvertInteger,
  2352.                        NULL,0,XtCacheNone,NULL);
  2353.     XtSetTypeConverter("VerticalDimension","String",MidasConvertInteger,
  2354.                        NULL,0,XtCacheNone,NULL);
  2355.     XtSetTypeConverter("HorizontalDimension","String",MidasConvertInteger,
  2356.                        NULL,0,XtCacheNone,NULL);
  2357.     XtSetTypeConverter("Dimension","String",MidasConvertInteger,
  2358.                        NULL,0,XtCacheNone,NULL);
  2359.     XtSetTypeConverter("Int","String",MidasConvertInteger,
  2360.                        NULL,0,XtCacheNone,NULL);
  2361.     XtSetTypeConverter("Short","String",MidasConvertInteger,
  2362.                        NULL,0,XtCacheNone,NULL);
  2363.     XtSetTypeConverter("Cardinal","String",MidasConvertInteger,
  2364.                        NULL,0,XtCacheNone,NULL);
  2365.     XtSetTypeConverter("String","Callback",MidasConvertStringToCallback,
  2366.                        NULL,0,XtCacheNone,NULL);
  2367.     XtSetTypeConverter("Callback","String",MidasConvertCallbackToString,
  2368.                        NULL,0,XtCacheNone,NULL);
  2369.     XtSetTypeConverter("Boolean","String",MidasConvertEnum,
  2370.                        ConvertBooleanArg,1,XtCacheNone,NULL);
  2371.     XtSetTypeConverter("Packing","String",MidasConvertEnum,
  2372.                        ConvertPackingArg,1,XtCacheNone,NULL);
  2373.  
  2374.     MidasDeclareInit();
  2375.     MidasConvertInit();
  2376.     MidasDeclareQualifier("PARENT","Widget");
  2377.     MidasDeclareQualifier("UIDFILE","name");
  2378.     MidasDeclareQualifier("ICON","Icon");
  2379.     MidasDeclareQualifier("DIALOG","");
  2380.     MidasDeclareFunction("STRNSPN(name,name)"               ,MidasStrnspn);
  2381.     MidasDeclareFunction("GETWIDGETID(Widget)"              ,MidasGetWidgetId);
  2382.     MidasDeclareFunction("HASCHILDREN(Widget)"              ,MidasHasChildren);
  2383.     MidasDeclareFunction("CHILDRENINTREE(Widget)"           ,MidasChildrenInTree);
  2384.     MidasDeclareFunction("ISMANAGED(Widget)"                ,MidasIsManaged);
  2385.     MidasDeclareFunction("ISREALIZED(Widget)"               ,MidasIsRealized);
  2386.     MidasDeclareFunction("GETVALUE(Widget,name)"            ,MidasGetValue);
  2387.     MidasDeclareFunction("GETAPPRESOURCE(Widget,name)"      ,MidasGetAppResource);
  2388.     MidasDeclareFunction("EVALU8(name)"                     ,MidasEvaluateExpression);
  2389.     MidasDeclareFunction("INT(Float)"                       ,MidasInt);
  2390.     MidasDeclareFunction("FETCH(name,{Widget})"             ,MidasFetchFunction);
  2391.     MidasDeclareFunction("WIDGET(Widget)"                   ,MidasWidgetFunction);
  2392.     MidasDeclareFunction("WIDGETNAME(Widget)"               ,MidasWidgetName);
  2393.     MidasDeclareFunction("WIDGETCLASS(Widget)"              ,MidasWidgetClass);
  2394.     MidasDeclareFunction("PARENT(Widget)"                   ,MidasParent);
  2395.     MidasDeclareFunction("SHELL(Widget)"                    ,MidasShellFunction);
  2396.     MidasDeclareFunction("TYPE(any)"                        ,MidasGetOperandType);
  2397.     MidasDeclareFunction("GETCOMMAND()"                     ,MidasGetCommand);
  2398.     MidasDeclareFunction("GETCLICKCOUNT()"                  ,MidasGetClickCount);
  2399.     MidasDeclareFunction("HYPERGETTEXT()"                   ,MidasHyperGetText);
  2400.     MidasDeclareFunction("HYPERGETHIDDEN()"                 ,MidasHyperGetHidden);
  2401.     MidasDeclareFunction("QUERYUSER(Widget)"                ,MidasQueryUser);
  2402.     MidasDeclareFunction("HYPERGREP(Widget,name)"           ,MidasHyperGrep);
  2403.     MidasDeclareFunction("TREETOWIDGET(Widget)"             ,MidasTreeToWidget);
  2404.     MidasDeclareVerb("MIDAS *name..."                       ,MidasIgnore);
  2405.     MidasDeclareVerb("POPUP        Widget"                  ,MidasPopup);
  2406.     MidasDeclareVerb("POPDOWN      Widget"                  ,MidasPopdown);
  2407.     MidasDeclareVerb("TOGGLE       Widget"                  ,MidasToggle);
  2408.     MidasDeclareVerb("FETCH        name {Widget}"           ,MidasFetch);
  2409.     MidasDeclareVerb("DESTROY      Widget"                  ,MidasDestroy);
  2410.     MidasDeclareVerb("OPEN UID     name {Widget}"           ,MidasOpenUidFile);
  2411.     MidasDeclareVerb("CREATE SHELL name"                    ,MidasCreateShell);
  2412.     MidasDeclareVerb("CREATE WIDGET TREE Widget"            ,MidasCreateWidgetTree);
  2413.     MidasDeclareVerb("CREATE DIALOG name"                   ,MidasCreateDialog);
  2414.     MidasDeclareVerb("CREATE WIDGET Widget Class name"      ,MidasCreateWidget);
  2415.     MidasDeclareVerb("QUIT"                                 ,MidasQuit);
  2416.     MidasDeclareVerb("REGISTER NAME name Widget"            ,MidasRegisterName);
  2417.     MidasDeclareVerb("TOGGLE CHILDREN Widget"               ,MidasToggleChildrenTree);
  2418.     MidasDeclareVerb("GET CALLBACKS list Widget"            ,MidasGetCallbacks);
  2419.     MidasDeclareVerb("GET RESOURCES list Widget"            ,MidasGetResources);
  2420.     MidasDeclareVerb("SET VALUE Widget name any..."         ,MidasSetValue);    
  2421.     MidasDeclareVerb("SET SENSITIVE Widget Boolean"         ,MidasSetSensitive);    
  2422.     MidasDeclareVerb("SAVE GEOMETRY Widget"                 ,MidasSaveGeometry);
  2423.     MidasDeclareVerb("STORE RESOURCE Widget name"           ,MidasStoreResource);
  2424.     MidasDeclareVerb("STORE APP RESOURCE Widget name name"  ,MidasStoreAppResource);
  2425.     MidasDeclareVerb("SAVE STORED RESOURCES Widget"         ,MidasSaveStoredResources);
  2426.     MidasDeclareVerb("CENTER HORIZONTAL Widget Int"         ,MidasCenterHorizontal);
  2427.     MidasDeclareVerb("CLEAR WINDOW Widget",                  MidasClearWindow);
  2428.     MidasDeclareVerb("CURRENT WIDGET IN TREE Widget"        ,MidasCurrentWidgetInTree);
  2429.     MidasDeclareVerb("IF Boolean *name...",                  MidasIf);
  2430.     MidasDeclareVerb("ELSE IF Boolean *name...",             MidasElseIf);
  2431.     MidasDeclareVerb("ELSE *name...",                        MidasElse);
  2432.     MidasDeclareVerb("INVOKE ACTION Widget name",            MidasInvokeAction);
  2433.     MidasDeclareVerb("INVOKE CALLBACK Widget name",          MidasInvokeCallback);
  2434.     MidasDeclareVerb("LOAD IMAGE name",                      MidasLoadImage);
  2435.     MidasDeclareVerb("FLUSH Widget",                         MidasFlush);
  2436.     MidasDeclareVerb("UPDATE Widget",                        MidasUpdate);
  2437.     MidasDeclareVerb("FORCE DIALOG Widget",                  MidasForceDialog); 
  2438.     MidasDeclareVerb("SYSTEM name...",                       MidasSystem);
  2439.     MidasDeclareVerb("INVOKE APPLICATION name",              MidasInvokeApplication);
  2440.     MidasDeclareVerb("SET CURSOR Widget Cursor",             MidasSetCursor);
  2441.     MidasDeclareVerb("ERROR name...",                        MidasError);
  2442.     MidasDeclareVerb("BEEP {Int} {Widget}",                  MidasBeep);
  2443.     MidasDeclareVerb("HYPER LOAD FILE Widget name",          SGMLHyperLoadFile);
  2444.     MidasDeclareVerb("LIST SELECT ITEM Widget XmString {Boolean}",XmListSelectItem);
  2445.     MidasDeclareVerb("HELP ON CONTEXT Widget",               MidasHelpOnContext);
  2446.         
  2447.     MidasUtilInit();
  2448.     MidasListInit();
  2449.     MidasInitializeIngots();
  2450.  
  2451.     /* Initialize the X Toolkit. We get back a top level shell widget. */
  2452.  
  2453.     XtToolkitInitialize();
  2454.  
  2455.     app_context = XtCreateApplicationContext();
  2456.  
  2457.     /* declare SendMidas action routine */
  2458.  
  2459.     XtAppAddActions(app_context,actions,XtNumber(actions));
  2460.  
  2461.     /* Parse the special midas translations */
  2462.  
  2463.     MidasTranslations = XtParseTranslationTable("Ctrl <Btn1Down> : MidasSpecial(\"Set Ingot WidgetList currentWidget Widget(.):dialog;Popup MidasInfo:parent=WidgetList;Register Name WidgetName(.) .\")");
  2464.                                                                   
  2465.     toplevel_widget = MidasCreateShellArg("Midas",argv,&argc);
  2466.     
  2467.     /* Open the UID files (the output of the UIL compiler) in the hierarchy*/
  2468.  
  2469.     MidasHierarchy = MidasOpenUidFile("midas.uid",toplevel_widget);
  2470.  
  2471.     /* Register the items MRM needs to bind for us. */
  2472.  
  2473.     MrmRegisterNames(reglist,XtNumber(reglist));
  2474.  
  2475.     /* Go get the midas pixmap */
  2476.  
  2477.     PixMap = MidasFetchIcon("MidasIcon");
  2478.  
  2479.     { int n = 0;
  2480.       Arg args[10];
  2481.       XtSetArg(args[n],XmNiconPixmap, PixMap); n++;
  2482.       XtSetValues(toplevel_widget, args, n);
  2483.     }
  2484.  
  2485.     /* Initialize Customization stuff */
  2486.  
  2487.     CustomInit();
  2488.  
  2489.     /* Invoke the users profile */
  2490.  
  2491.     {
  2492.       char *AppName, *AppClass;
  2493.       XtGetApplicationNameAndClass(XtDisplay(toplevel_widget),&AppName,&AppClass); 
  2494.       /* printf("Application name %s",AppName); */
  2495.  
  2496.       if (strcmp(AppName,"midas") && strcmp(AppName,"MIDAS") && strcmp(AppName,"Midas"))
  2497.         {
  2498.           toplevel_widget = MidasCreateShell(AppName);
  2499.         }
  2500.     }
  2501.  
  2502.     Temp = MidasGetAppResource(toplevel_widget,"startup");
  2503.     /* printf("\nThe startup string is %s\n",Temp.Value.P); */
  2504.  
  2505.     if (*Temp.Value.P != '\0') MidasQueueCommand(toplevel_widget,Temp.Value.P);
  2506.     else                       MidasQueueCommand(toplevel_widget,"Midas Popup Midas_Main");
  2507.  
  2508. };
  2509.